package com.elitel.frame.base.component;

//import com.elitel.common.redis.RedisDbIndex;
//import com.elitel.common.redis.service.RedisCacheService;

import com.elitel.frame.base.service.*;
import com.elitel.frame.main.entity.*;
import com.elitel.frame.main.entity.vo.ZTreeDataModelVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Component("redisCacheComponent")
public class RedisCacheComponent {
    @Autowired
    private CfgExtendService cfgExtendService;
    @Autowired
    private CfgTableService cfgTableService;
    @Autowired
    private CfgFieldService cfgFieldService;
    @Autowired
    private CfgDbService cfgDbService;
    //    @Autowired
//    private RedisCacheService redisCacheService;
    @Autowired
    private CfgExtrepService cfgExtrepService;
    @Autowired
    private CfgEditService cfgEditService;
    @Autowired
    private CfgExtsearchService cfgExtsearchService;
    //    @Autowired
//    private RedisConnInfo redisConnInfo;
    @Autowired
    private CacheCollections cacheCollections;

    /**
     * <pre>cfgExtendRedisCache(缓存服务表信息)
     * @author：FanWenquan
     * @date：2017年9月11日 下午4:40:25
     * @return CfgExtend
     *
     * modify by guoyanfei on 2019/07/16
     * 新增验证redis连通性
     * @see
     */
    public CfgExtend cfgExtendRedisCache(String serviceID) {
        // 原使用redis缓存代码
//         int xx = RedisDbIndex.value;
//         List<CfgExtend> list = new ArrayList<CfgExtend>();
//         String key = "CFG_EXTEND";
//
//         if (redisConnInfo.checkConnReids()) {
//         if (redisCacheService.stringExists(key, xx)) {
//         String cfgStr = redisCacheService.getObject(key, xx);
//         list = (List<CfgExtend>) JSON.parseArray(cfgStr, CfgExtend.class);
//         } else {
//         list = cfgExtendService.selectAllExtend();
//         String extendStr = JSON.toJSONString(list);
//         redisCacheService.saveObject(key, extendStr, xx);
//         }
//         } else {
//         list = cfgExtendService.selectAllExtend();
//         }

        //使用springcache缓存
        List<CfgExtend> CfgExtends = cacheCollections.getCfgExtends();

        CfgExtend cfgExtend = new CfgExtend();
        for (CfgExtend ce : CfgExtends) {
            if (null != serviceID && serviceID.equals(ce.getGuid())) {
                cfgExtend = ce;
                break;
            }
        }
        return cfgExtend;
    }


    public Map<String, String> selectDbKeyByServiceCodes(List<String> serviceCodes) {

        Map<String, String> res = new HashMap<>();
        //使用springcache缓存
        List<CfgExtend> cfgExtendList = cacheCollections.getCfgExtends();
        for (String serviceCode : serviceCodes) {
            cfgExtendList.stream().filter(i -> i.getGuid().equals(serviceCode)).findFirst().ifPresent(i -> res.put(serviceCode, i.getDbKey()));
        }
        return res;
    }

    /**
     * <pre>freshExtendRedisCache(刷新服务表缓存)
     * @author：FanWenquan
     * @date：2017年9月11日 下午3:37:50   </pre>
     * <p>
     * modify by guoyanfei on 2019/07/16
     * 新增验证redis连通性
     *
     * @see
     */
    @CachePut(cacheNames = CacheConfig.DEFAULT, key = "'CFG_EXTEND'")
    public List<CfgExtend> freshExtendRedisCache() {
//        if (!redisConnInfo.checkConnReids()) return;
//
//        int xx = RedisDbIndex.value;
//        List<CfgExtend> list = cfgExtendService.selectAllExtend();
//        String key = "CFG_EXTEND";
//        String extendStr = JSON.toJSONString(list);
//        redisCacheService.saveObject(key, extendStr, xx);
        List<CfgExtend> list = cfgExtendService.selectAllExtend();
        return list;
    }

    /**
     * <pre>cfgDBRedisCache(缓存数据源表信息)
     * @author：FanWenquan
     * @date：2017年9月11日 下午5:00:19
     * @param dbKey
     * @return</pre>
     * <p>
     * modify by guoyanfei on 2019/07/16
     * 新增验证redis连通性
     *
     * @see
     */
    public CfgDb cfgDBRedisCache(String dbKey) {
//        int xx = RedisDbIndex.value;
//        List<CfgDb> list = new ArrayList<CfgDb>();
//        if (redisConnInfo.checkConnReids()) {
//            String key = "CFG_DB";
//            if (redisCacheService.stringExists(key, xx)) {
//                String cfgStr = redisCacheService.getObject(key, xx);
//                list = (List<CfgDb>) JSON.parseArray(cfgStr, CfgDb.class);
//            } else {
//                list = cfgDbService.getAllListCfgDb();
//                String extendStr = JSON.toJSONString(list);
//                redisCacheService.saveObject(key, extendStr, xx);
//            }
//        } else {
//            list = cfgDbService.getAllListCfgDb();
//        }

        List<CfgDb> cfgDBs = cacheCollections.getCfgDBs();

        CfgDb cfgDb = new CfgDb();
        for (CfgDb ce : cfgDBs) {
            if (null != dbKey && dbKey.equals(ce.getDbKey())) {
                cfgDb = ce;
                break;
            }
        }
        return cfgDb;
    }

    /**
     * <pre>freshCfgDBRedisCache(刷新数据源表缓存)
     * @author：FanWenquan
     * @date：2017年9月11日 下午5:01:51   </pre>
     * <p>
     * modify by guoyanfei on 2019/07/16
     * 新增验证redis连通性
     *
     * @see
     */
    @CachePut(cacheNames = CacheConfig.DEFAULT, key = "'CFG_DB'")
    public List<CfgDb> freshCfgDBRedisCache() {
//        if (!redisConnInfo.checkConnReids()) return;
//
//        int xx = RedisDbIndex.value;
//        List<CfgDb> list = cfgDbService.getAllListCfgDb();
//        String key = "CFG_DB";
//        String cfgDBStr = JSON.toJSONString(list);
//        redisCacheService.saveObject(key, cfgDBStr, xx);
        List<CfgDb> list = cfgDbService.getAllListCfgDb();
        return list;
    }

    /**
     * <pre>cfgTableRedisCache(服务根据数据源查询表信息缓存)
     * @author：FanWenquan
     * @date：2017年9月11日 下午5:46:28
     * @param dtConfigID 所属表标识
     * @param key  表信息缓存的键为数据源主键
     * @return</pre>
     * <p>
     * modify by guoyanfei on 2019/07/16
     * 新增验证redis连通性
     *
     * @see
     */
    public CfgTable cfgTableRedisCache(String dtConfigID, String key) {
//        int xx = RedisDbIndex.value;
//        List<CfgTable> list = new ArrayList<CfgTable>();
//        if (redisConnInfo.checkConnReids()) {
//            if (redisCacheService.stringExists(key, xx)) {
//                String cfgStr = redisCacheService.getObject("CFG_TABLE_" + key, xx);
//                list = (List<CfgTable>) JSON.parseArray(cfgStr, CfgTable.class);
//            } else {
//                list = cfgTableService.getListbyConn(key);
//                String extendStr = JSON.toJSONString(list);
//                redisCacheService.saveObject("CFG_TABLE_" + key, extendStr, xx);
//            }
//        } else {
//            list = cfgTableService.getListbyConn(key);
//        }

        List<CfgTable> cfgTables = cacheCollections.getCfgTables(key);

        CfgTable cfgTable = new CfgTable();
        for (CfgTable ce : cfgTables) {
            if (null != dtConfigID && dtConfigID.equals(ce.getDtConfigId())) {
                cfgTable = ce;
                break;
            }
        }
        return cfgTable;
    }

    /**
     * <pre>freshCfgTableRedisCache(刷新服务表信息缓存)
     * @author：FanWenquan
     * @date：2017年9月11日 下午5:49:32
     * @param key</pre>
     * <p>
     * modify by guoyanfei on 2019/07/16
     * 新增验证redis连通性
     *
     * @see
     */
    @CachePut(cacheNames = CacheConfig.DEFAULT, key = "'CFG_TABLE_'+#key")
    public List<CfgTable> freshCfgTableRedisCache(String key) {
//        if (!redisConnInfo.checkConnReids()) return;
//
//        int xx = RedisDbIndex.value;
//        List<CfgTable> list = cfgTableService.getListbyConn(key);
//        String cfgTableStr = JSON.toJSONString(list);
//        redisCacheService.saveObject("CFG_TABLE_" + key, cfgTableStr, xx);
        List<CfgTable> list = cfgTableService.getListbyConn(key);
        return list;
    }

    /**
     * <pre>cfgFieldRedisCache(根据dtConfigID标识缓存字段表信息)
     * @author：FanWenquan
     * @date：2017年9月11日 下午6:10:15
     * @param dtConfigID 表标识为字段信息缓存键
     * @return</pre>
     * <p>
     * modity by guoyanfei on 2019/07/16
     * 新增验证redis是否连通
     *
     * @see
     */
    @Cacheable(cacheNames = "DEFAULT", key = "'CFG_FIELD_'+#dtConfigID")
    public List<CfgField> cfgFieldRedisCache(String dtConfigID) {
//        int xx = RedisDbIndex.value;
//        List<CfgField> list = new ArrayList<CfgField>();
//        if (redisConnInfo.checkConnReids()) {
//            if (redisCacheService.stringExists(dtConfigID, xx)) {
//                String cfgStr = redisCacheService.getObject("CFG_FIELD_" + dtConfigID, xx);
//                list = (List<CfgField>) JSON.parseArray(cfgStr, CfgField.class);
//            } else {
//                list = cfgFieldService.selectFieldByConfig(dtConfigID);
//                String extendStr = JSON.toJSONString(list);
//                redisCacheService.saveObject("CFG_FIELD_" + dtConfigID, extendStr, xx);
//            }
//        } else {
//            list = cfgFieldService.selectFieldByConfig(dtConfigID);
//        }

        List<CfgField> list = cfgFieldService.selectFieldByConfig(dtConfigID);

        return list;
    }

    /**
     * <pre>freshCfgFieldRedisCache(刷新表字段信息缓存)
     * @author：FanWenquan
     * @date：2017年9月11日 下午6:09:34
     * @param key</pre>
     * <p>
     * modify by guoyanfei on 2019/07/16
     * 新增验证redis是否连通
     *
     * @see
     */
    @CachePut(cacheNames = CacheConfig.DEFAULT, key = "'CFG_FIELD_'+#key")
    public List<CfgField> freshCfgFieldRedisCache(String key) {
//        if (!redisConnInfo.checkConnReids()) return;
//
//        int xx = RedisDbIndex.value;
//        List<CfgField> list = cfgFieldService.selectFieldByConfig(key);
//        String cfgTableStr = JSON.toJSONString(list);
//        redisCacheService.saveObject("CFG_FIELD_" + key, cfgTableStr, xx);
        List<CfgField> list = cfgFieldService.selectFieldByConfig(key);
        return list;
    }

    @CacheEvict(cacheNames = CacheConfig.DEFAULT, key = "'CFG_FIELD_'+#key")
    public void delCfgFieldRedisCache(String key) {
    }

    /**
     * <pre>freshTreeReportData(刷新报表树缓存)
     * @author：FanWenquan
     * @date：2017年9月12日 下午2:06:11   </pre>
     * <p>
     * modify by guoyanfei on 2019/07/16
     * 新增验证redis连通性
     *
     * @see
     */
    @CachePut(cacheNames = CacheConfig.DEFAULT, key = "'TREE_repotData'")
    public List<ZTreeDataModelVo> freshTreeReportData() {
//        if (!redisConnInfo.checkConnReids()) return;
//
//        int xx = RedisDbIndex.value;
//        List<ZTreeDataModelVo> list = cfgExtrepService.getAllTreeList();
//        String key = "TREE_repotData";
//        String trStr = JSON.toJSONString(list);
//        redisCacheService.saveObject(key, trStr, xx);
        List<ZTreeDataModelVo> list = cfgExtrepService.getAllTreeList();
        return list;
    }

    /**
     * @param serviceID(服务ID)
     * @return CfgEdit实体
     * @Description 通过服务ID查询缓存单表编辑服务信息
     * @author guoyanfei
     * @date 2018/01/08
     * <p>modify by guoyanfei on 2019/07/16 新增验证redis连通性
     * @see
     */

    public CfgEdit cfgEditRedisCache(String serviceID) {
//        int xx = RedisDbIndex.value;
//        CfgEdit cfgEdit = null;
//        List<CfgEdit> cfgEditList = new ArrayList<CfgEdit>();
//        String key = "CFG_EDIT";
//        if (redisConnInfo.checkConnReids()) {
//            if (redisCacheService.stringExists(key, xx)) {
//                String strCfgEdit = redisCacheService.getObject(key, xx);
//                cfgEditList = (List<CfgEdit>) JSON.parseArray(strCfgEdit, CfgEdit.class);
//            } else {
//                cfgEditList = cfgEditService.selectAllCfgEdit();
//                String strCfgEdit = JSON.toJSONString(cfgEditList);
//                redisCacheService.saveObject(key, strCfgEdit, xx);
//            }
//        } else {
//            cfgEditList = cfgEditService.selectAllCfgEdit();
//        }

        CfgEdit cfgEdit = new CfgEdit();
        List<CfgEdit> cfgEdits = cacheCollections.cfgEdits();

        if (cfgEdits != null && cfgEdits.size() > 0) {
            for (CfgEdit cfge : cfgEdits) {
                if (cfge.getGuid().equals(serviceID)) {
                    cfgEdit = cfge;
                }
            }
        }
        return cfgEdit;
    }

    /**
     * @Description 刷新单表编辑服务基本信息Redis缓存
     * @author guoyanfei
     * @date 2018/01/08
     * <p>modify by guoyanfei on 2019/07/16 新增验证redis连通性
     * @see
     */
    @CachePut(cacheNames = CacheConfig.DEFAULT, key = "'CFG_EDIT'")
    public List<CfgEdit> refreshCfgEditRedisCache() {
//        if (!redisConnInfo.checkConnReids()) return;
//
//        int xx = RedisDbIndex.value;
//        List<CfgEdit> cfgEdits = cfgEditService.selectAllCfgEdit();
//        String key = "CFG_EDIT";
//        String strCfgEdit = JSON.toJSONString(cfgEdits);
//        redisCacheService.saveObject(key, strCfgEdit, xx);
        List<CfgEdit> cfgEdits = cfgEditService.selectAllCfgEdit();
        return cfgEdits;
    }

    /**
     * 通过serviceID查询全文检索服务基本信息redis缓存 created on 2018/03/28
     *
     * @param serviceID 服务ID
     * @return CfgExtsearch实体
     * @author guoyanfei
     * <p>modify by guoyanfei on 2019/07/16 新增验证redis连通性
     * @see
     */

    public CfgExtsearch selectCfgExtSearchRedisCache(String serviceID) {
//        int xx = RedisDbIndex.value;
//        CfgExtsearch cfgExtsearch = new CfgExtsearch();
//        List<CfgExtsearch> cfgExtsearchList = new ArrayList<>();
//        if (redisConnInfo.checkConnReids()) {
//            String key = "CFG_EXTSEARCH";
//            if (redisCacheService.stringExists(key, xx)) {
//                String strcfgExtsearch = redisCacheService.getObject(key, xx);
//                cfgExtsearchList =
//                        (List<CfgExtsearch>) JSON.parseArray(strcfgExtsearch, CfgExtsearch.class);
//            } else {
//                cfgExtsearchList = cfgExtsearchService.selectAllCfgExtSearch();
//                String strCfgEdit = JSON.toJSONString(cfgExtsearchList);
//                redisCacheService.saveObject(key, strCfgEdit, xx);
//            }
//        } else {
//            cfgExtsearchList = cfgExtsearchService.selectAllCfgExtSearch();
//        }

        CfgExtsearch cfgExtsearch = new CfgExtsearch();
        List<CfgExtsearch> cfgExtSearchs = cacheCollections.getCfgExtSearchs();

        if (cfgExtSearchs != null && cfgExtSearchs.size() > 0) {
            for (CfgExtsearch cfges : cfgExtSearchs) {
                if (cfges.getGuid().equals(serviceID)) {
                    cfgExtsearch = cfges;
                }
            }
        }

        return cfgExtsearch;
    }

    /**
     * 刷新全文检索服务基本信息redis缓存 created by guoyanfei on 2018/03/28
     *
     * <p>modify by guoyafei on 2019/07/16 新增验证redis连通性
     *
     * @see
     */
    @CachePut(cacheNames = CacheConfig.DEFAULT, key = "'CFG_EXTSEARCH'")
    public List<CfgExtsearch> refreshCfgExtSearchRedisCache() {
//        if (!redisConnInfo.checkConnReids()) return;
//
//        int xx = RedisDbIndex.value;
//        List<CfgExtsearch> cfgExtsearches = cfgExtsearchService.selectAllCfgExtSearch();
//        String key = "CFG_EXTSEARCH";
//        String strCfgExtsearch = JSON.toJSONString(cfgExtsearches);
//        redisCacheService.saveObject(key, strCfgExtsearch, xx);
        List<CfgExtsearch> cfgExtsearches = cfgExtsearchService.selectAllCfgExtSearch();
        return cfgExtsearches;

    }
}
